import java.util.ArrayList;
import java.util.Random;

/**
 * 习题集类，用于生成和管理加减法习题
 * 继承自ArrayList<BinaryOperation2>，支持动态存储习题
 */
public class Exercise2 extends ArrayList<BinaryOperation2> {
    private static final Random random = new Random(); // 提取为静态随机数生成器，避免重复创建
    private static final int DEFAULT_COLUMN_WIDTH = 20; // 默认列宽，确保对齐

    // 默认构造方法
    public Exercise2() {
        super();
    }

    /**
     * 检查习题集中是否包含指定的算式（重写以提高可读性）
     * @param operation 待检查的算式
     * @return 存在返回true，否则返回false
     */
    @Override
    public boolean contains(Object operation) {
        if (!(operation instanceof BinaryOperation2)) {
            return false; // 非BinaryOperation2类型直接返回false
        }
        BinaryOperation2 target = (BinaryOperation2) operation;
        for (BinaryOperation2 op : this) {
            if (op.equals(target)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 生成指定数量的加法习题（确保无重复且结果不超过100）
     * @param operationCount 习题数量（必须为正整数）
     * @throws IllegalArgumentException 若数量小于等于0则抛出异常
     */
    public void generateAdditionExercise(int operationCount) {
        validateCount(operationCount); // 校验参数合法性
        this.clear();

        int generatedCount = 0;
        while (generatedCount < operationCount) {
            AdditionOperation2 newOp = new AdditionOperation2();
            if (newOp.getValue() <= 100 && !contains(newOp)) {
                this.add(newOp);
                generatedCount++;
            }
        }
    }

    /**
     * 生成指定数量的减法习题（确保无重复、结果非负且不超过100）
     * @param operationCount 习题数量（必须为正整数）
     * @throws IllegalArgumentException 若数量小于等于0则抛出异常
     */
    public void generateSubtractExercise(int operationCount) {
        validateCount(operationCount);
        this.clear();

        int generatedCount = 0;
        while (generatedCount < operationCount) {
            // 调用工具方法生成合法的减法操作数（避免重复逻辑）
            int[] operands = generateValidSubtractOperands();
            SubtractOperation2 newOp = new SubtractOperation2(operands[0], operands[1]);
            
            if (newOp.getValue() <= 100 && !contains(newOp)) {
                this.add(newOp);
                generatedCount++;
            }
        }
    }

    /**
     * 生成指定数量的加减法混合习题（随机混合，无重复且结果不超过100）
     * @param operationCount 习题总数量（必须为正整数）
     * @throws IllegalArgumentException 若数量小于等于0则抛出异常
     */
    public void generateBinaryExercise(int operationCount) {
        validateCount(operationCount);
        this.clear();

        int generatedCount = 0;
        while (generatedCount < operationCount) {
            // 随机选择生成加法或减法（增强随机性，避免先加后减的固定顺序）
            if (random.nextBoolean()) {
                // 生成加法
                AdditionOperation2 addOp = new AdditionOperation2();
                if (addOp.getValue() <= 100 && !contains(addOp)) {
                    this.add(addOp);
                    generatedCount++;
                }
            } else {
                // 生成减法
                int[] operands = generateValidSubtractOperands();
                SubtractOperation2 subOp = new SubtractOperation2(operands[0], operands[1]);
                if (subOp.getValue() <= 100 && !contains(subOp)) {
                    this.add(subOp);
                    generatedCount++;
                }
            }
        }
    }

    /**
     * 格式化显示习题（默认5列，自动对齐）
     */
    public void formatAndDisplay() {
        formatAndDisplay(5);
    }

    /**
     * 指定列数格式化显示习题（固定列宽确保对齐）
     * @param columnsPerRow 每行显示的列数（必须为正整数）
     * @throws IllegalArgumentException 若列数小于等于0则抛出异常
     */
    public void formatAndDisplay(int columnsPerRow) {
        validateColumns(columnsPerRow);
        System.out.println("\n格式化显示习题（" + columnsPerRow + "列）：");

        for (int i = 0; i < this.size(); i++) {
            BinaryOperation2 op = this.get(i);
            // 格式化每道题：序号 + 算式，左对齐固定列宽
            String formatted = String.format("%d. %s", (i + 1), op.toString());
            System.out.print(String.format("%-" + DEFAULT_COLUMN_WIDTH + "s", formatted));

            // 控制换行：每columnsPerRow道题换行
            if ((i + 1) % columnsPerRow == 0) {
                System.out.println();
            }
        }

        // 最后一行若未满列，补充换行
        if (this.size() % columnsPerRow != 0) {
            System.out.println();
        }
    }

    // ------------------------------ 私有工具方法 ------------------------------

    /**
     * 生成合法的减法操作数（被减数 >= 减数，确保结果非负）
     * @return 长度为2的数组：[0]被减数，[1]减数
     */
    private int[] generateValidSubtractOperands() {
        int left = random.nextInt(100); // 被减数：0~99
        int right = random.nextInt(left + 1); // 减数：0~left（确保不超过被减数）
        return new int[]{left, right};
    }

    /**
     * 校验习题数量合法性（必须为正整数）
     * @param count 待校验的数量
     * @throws IllegalArgumentException 若数量 <= 0则抛出异常
     */
    private void validateCount(int count) {
        if (count <= 0) {
            throw new IllegalArgumentException("习题数量必须为正整数（当前：" + count + "）");
        }
    }

    /**
     * 校验列数合法性（必须为正整数）
     * @param columns 待校验的列数
     * @throws IllegalArgumentException 若列数 <= 0则抛出异常
     */
    private void validateColumns(int columns) {
        if (columns <= 0) {
            throw new IllegalArgumentException("列数必须为正整数（当前：" + columns + "）");
        }
    }
}